tsunami/engine/rootelem.go (2)

86-99: Prefix filter helper is good; clarify key behavior in comment

Helper returns a snapshot with keys stripped of the prefix. Consider noting “keys are prefix-stripped” in the doc to avoid misuse.

---

110-117: Minor duplication: consider unifying GetDataMap/GetConfigMap

Both functions are identical except the prefix. A small helper like getAtomVals(prefix) could reduce duplication.

tsunami/engine/atomimpl.go (1)

12-20: Document AtomMeta immutability expectations

If callers shouldn’t mutate metadata after construction, add a brief comment stating it’s treated as immutable at runtime.

tsunami/util/util.go (1)

242-285: JSON tag parsing utility looks good; add tests and edge-case notes

Solid baseline. Recommend unit tests covering: json:"-", json:",omitempty,string", empty tag, renamed fields, unknown options retention, and embedded fields. If embedded/inline fields will be handled by schema code, document expectations here.

I can draft a small test table for ParseJSONTag; want me to add it?

tsunami/engine/serverhandlers.go (1)

265-291: Small hardening and client caching behavior.

• Add defensive headers; optionally disable caching since schemas may change during runtime.

Apply within this block:

 w.Header().Set("Content-Type", "application/json")
+// schemas may change as atoms register/unregister; avoid stale caches
+w.Header().Set("Cache-Control", "no-store")
+// conservative hardening
+w.Header().Set("X-Content-Type-Options", "nosniff")
 if err := json.NewEncoder(w).Encode(result); err != nil {

If schema generation is non-trivial, consider caching the computed config/data schemas with an invalidation hook on atom registration to avoid recomputing on every GET.

tsunami/app/atom.go (1)

25-29: Atom[T] wrapper is clean.

API matches existing usage (Get/Set/SetFn). No issues.

To avoid false-positive mutation warnings when both current and new values are nil pointers, consider this tweak to sameRef (outside the changed lines):

func sameRef[T any](oldVal, newVal T) bool {
    vOld, vNew := reflect.ValueOf(oldVal), reflect.ValueOf(newVal)
    if !vOld.IsValid() || !vNew.IsValid() { return false }
    switch vNew.Kind() {
    case reflect.Ptr:
        if vOld.IsNil() || vNew.IsNil() { return false }
        return any(oldVal) == any(newVal)
    case reflect.Map, reflect.Slice:
        if vOld.Kind() != vNew.Kind() || vOld.IsZero() || vNew.IsZero() { return false }
        return vOld.Pointer() == vNew.Pointer()
    }
    return false
}

tsunami/demo/githubaction/app.go (1)

20-25: Well-chosen metadata across config/data atoms.

• pollInterval: Units + min/max are appropriate.
• repository/workflow: Patterns constrain inputs correctly.
• maxWorkflowRuns: Reasonable bounds.
• Data atoms: Helpful descriptions for observability.

UI copy says “Polls GitHub API every 5 seconds…” (Line 414) but poll interval is configurable; consider reflecting the current value or removing the hard-coded “5 seconds”.

Also applies to: 26-29, 30-33, 34-38, 39-41, 42-44, 45-47, 48-50

tsunami/demo/cpuchart/app.go (3)

14-18: Good use of AtomMeta with Min/Max; consider Units.

Optionally add Units: "%" for clarity in generated schemas.

-    Min:  app.Ptr(10.0),
-    Max:  app.Ptr(300.0),
+    Units: "%",
+    Min:   app.Ptr(10.0),
+    Max:   app.Ptr(300.0),

---

19-33: Add field-level schema tags to CPUDataPoint.

Improves generated schema (descriptions, units, ranges).

 type CPUDataPoint struct {
-    Time      int64    `json:"time"`      // Unix timestamp in seconds
-    CPUUsage  *float64 `json:"cpuUsage"`  // CPU usage percentage (nil for empty slots)
-    Timestamp string   `json:"timestamp"` // Human readable timestamp
+    Time      int64    `json:"time" desc:"Unix timestamp (seconds since epoch)" units:"s"`
+    CPUUsage  *float64 `json:"cpuUsage" desc:"CPU usage percentage" units:"%" min:"0" max:"100"`
+    Timestamp string   `json:"timestamp" desc:"Human-readable HH:MM:SS"`
 }

Also applies to: 36-40

---

71-73: Reduce noisy logs in tight ticker loop.

Per-second logs will spam debug output. Gate behind a verbose flag or reduce frequency.

- log.Printf("CPU Usage: %.2f%% at %s", cpuUsage, dataPoint.Timestamp)
+ if false { // TODO: wire to a verbose flag
+     log.Printf("CPU Usage: %.2f%% at %s", cpuUsage, dataPoint.Timestamp)
+ }

Also applies to: 153-161

tsunami/prompts/system.md (2)

459-470: Clarify AtomMeta parameter is optional (nil allowed).

Text says “require”; API accepts nil. Adjust wording to prevent confusion.

-ConfigAtom and DataAtom require an AtomMeta parameter
+ConfigAtom and DataAtom accept an AtomMeta parameter (pass nil if not needed)

---

1233-1240: Replace hard tabs with spaces to satisfy markdownlint (MD010).

Multiple lines flagged by markdownlint-cli2.

Also applies to: 1270-1290, 1292-1299, 1305-1318, 1336-1336

tsunami/engine/schema.go (1)

273-281: Consider adding “required” at root only if needed.

Currently all atoms are optional; that’s fine. If you later need required config keys, introduce a Required slice in metadata.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tsunami/engine/atomimpl.go (2)

101-106: Do not return internal pointer; return a clone

Expose a copy to avoid external mutation of internal state.

 func (a *AtomImpl[T]) GetMeta() *AtomMeta {
     a.lock.Lock()
     defer a.lock.Unlock()
-    return a.meta
+    return cloneAtomMeta(a.meta)
 }

---

30-36: Own the metadata: clone on construction to prevent external mutation/data races

Storing caller-provided meta directly allows unsynchronized mutation and schema drift. Clone it at construction.

 func MakeAtomImpl[T any](initialVal T, meta *AtomMeta) *AtomImpl[T] {
-    return &AtomImpl[T]{
-        lock:   &sync.Mutex{},
-        val:    initialVal,
-        usedBy: make(map[string]bool),
-        meta:   meta,
-    }
+    return &AtomImpl[T]{
+        lock:    &sync.Mutex{},
+        val:     initialVal,
+        usedBy:  make(map[string]bool),
+        meta:    cloneAtomMeta(meta),
+        valType: reflect.TypeOf((*T)(nil)).Elem(),
+    }
 }
+
+// cloneAtomMeta makes a deep copy so AtomImpl owns an immutable snapshot.
+func cloneAtomMeta(in *AtomMeta) *AtomMeta {
+    if in == nil {
+        return nil
+    }
+    out := *in
+    if in.Enum != nil {
+        out.Enum = append([]string(nil), in.Enum...)
+    }
+    if in.Min != nil {
+        v := *in.Min
+        out.Min = &v
+    }
+    if in.Max != nil {
+        v := *in.Max
+        out.Max = &v
+    }
+    return &out
+}

tsunami/engine/rootelem.go (1)

87-101: Minor: pre-size the result map

Micro-optimization: you can pre-size result to reduce rehashing.

- result := make(map[string]genAtom)
+ result := make(map[string]genAtom, len(r.Atoms))

tsunami/engine/serverhandlers.go (1)

277-305: /api/schemas handler: add Allow header on 405

For stricter HTTP semantics, advertise allowed methods when returning 405.

- if r.Method != http.MethodGet {
-     http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ if r.Method != http.MethodGet {
+     w.Header().Set("Allow", http.MethodGet)
+     http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
      return
  }

tsunami/demo/githubaction/app.go (1)

320-327: Use local isLoading variable instead of repeated atom.Get() calls

Reduces repeated reads and improves readability.

-                                "className": vdom.Classes(
-                                    "px-4 py-2 rounded-md text-sm font-medium transition-colors cursor-pointer",
-                                    vdom.IfElse(isLoadingAtom.Get(), "bg-gray-600 text-gray-400", "bg-blue-600 hover:bg-blue-700 text-white"),
-                                ),
-                                "onClick":  vdom.If(!isLoadingAtom.Get(), handleRefresh),
-                                "disabled": isLoadingAtom.Get(),
+                                "className": vdom.Classes(
+                                    "px-4 py-2 rounded-md text-sm font-medium transition-colors cursor-pointer",
+                                    vdom.IfElse(isLoading, "bg-gray-600 text-gray-400", "bg-blue-600 hover:bg-blue-700 text-white"),
+                                ),
+                                "onClick":  vdom.If(!isLoading, handleRefresh),
+                                "disabled": isLoading,

tsunami/prompts/system.md (5)

482-495: Use the proper package qualifier for AtomMeta in examples.

Examples currently use &AtomMeta{...} which can confuse readers. Prefer &app.AtomMeta{...} to match the actual API.

-    theme = app.ConfigAtom("theme", "dark", &AtomMeta{
+    theme = app.ConfigAtom("theme", "dark", &app.AtomMeta{
@@
-    apiKey = app.ConfigAtom("apiKey", "", &AtomMeta{
+    apiKey = app.ConfigAtom("apiKey", "", &app.AtomMeta{
@@
-    maxRetries = app.ConfigAtom("maxRetries", 3, &AtomMeta{
+    maxRetries = app.ConfigAtom("maxRetries", 3, &app.AtomMeta{

---

497-503: Same package-qualification fix for DataAtom examples.

-    currentUser = app.DataAtom("currentUser", UserStats{}, &AtomMeta{
+    currentUser = app.DataAtom("currentUser", UserStats{}, &app.AtomMeta{
@@
-    lastPollResult = app.DataAtom("lastPoll", APIResult{}, &AtomMeta{
+    lastPollResult = app.DataAtom("lastPoll", APIResult{}, &app.AtomMeta{

---

541-542: Document minimal response shape for /api/schemas.

Add a tiny example to reduce guesswork for integrators (top-level keys and where config vs data land). I can draft one if helpful.

---

550-559: Keep AtomMeta usage consistent here, too.

-userPrefs := app.ConfigAtom("userPrefs", UserPrefs{}, &AtomMeta{
+userPrefs := app.ConfigAtom("userPrefs", UserPrefs{}, &app.AtomMeta{

---

1235-1336: Resolve markdownlint MD010 (hard tabs).

The linter flags hard tabs across code examples. Either convert leading tabs to spaces in fenced blocks or disable MD010 for code fences in your markdownlint config:

• Convert: replace leading tabs in code blocks with 4 spaces.
• Or config: set MD010.code_blocks=false for this file.

Run your markdownlint locally to confirm the warnings are cleared.

tsunami/demo/cpuchart/app.go (2)

19-33: Avoid hard-coded 60 in initial data; derive from config to prevent first-tick resize.

Using a literal 60 forces a resize on the first tick when config differs. If safe at init time, read the current config:

-        dataPointCount := 60 // Default value for initialization
+        dataPointCount := dataPointCountAtom.Get() // Use configured window size

If calling Get() at package init is unsafe in your lifecycle, initialize with an empty slice here and seed size in App via a one-time effect that sets the slice to dataPointCountAtom.Get().

---

71-73: Reduce per-second logging noise.

Log each Nth sample or behind a debug flag to keep logs usable.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

tsunami/engine/schema.go (3)

81-86: Pattern tag support: resolved.

Field-level pattern is now applied for string fields. Looks good.

---

202-208: []byte schema uses contentEncoding/contentMediaType: good.

Correct switch away from nonstandard format: base64.

---

231-236: Avoid type-name collisions in $ref/$defs; use a fully-qualified def key.

t.Name() can collide across packages and overwrite defs. Use a stable key built from PkgPath()+Name in both $ref and $defs.

Apply this diff in-place:

-        schema["$ref"] = fmt.Sprintf("#/$defs/%s", t.Name())
+        schema["$ref"] = fmt.Sprintf("#/$defs/%s", defKey(t))

-    if len(defs) > 0 {
-        definitions := make(map[string]any)
-        for t, def := range defs {
-            definitions[t.Name()] = def
-        }
-        schema["$defs"] = definitions
-    }
+    if len(defs) > 0 {
+        defsOut := make(map[string]any)
+        for t, def := range defs {
+            defsOut[defKey(t)] = def
+        }
+        schema["$defs"] = defsOut
+    }

Add this helper (outside the ranges above, e.g., below imports):

// defKey builds a stable, unique key for type definitions.
func defKey(t reflect.Type) string {
	if t == nil {
		return ""
	}
	if t.PkgPath() == "" {
		return t.Name()
	}
	key := t.PkgPath() + "." + t.Name()
	return strings.ReplaceAll(key, "/", ".")
}

Also applies to: 279-286

tsunami/prompts/system.md (1)

459-460: Fix grammar and clarify AtomMeta optionality.

Use “accept an optional” and remove the double “not”.

-app.ConfigAtom and app.DataAtom require an app.AtomMeta parameter (can pass nil if not not needed) to provide schema information for external tools and AI agents. app.SharedAtom does not use app.AtomMeta since it's only for internal state sharing.
+app.ConfigAtom and app.DataAtom accept an optional app.AtomMeta parameter (pass nil when not needed) to provide schema information for external tools and AI agents. app.SharedAtom does not use app.AtomMeta because it is only for internal state sharing.

tsunami/engine/schema.go (2)

173-181: Constrain meta.Enum to strings (or coerce types) to avoid invalid schemas.

Right now enum values (strings) are set regardless of field type, which is invalid for numeric/bool schemas. Either gate to strings or parse to the target type.

-    // Add enum values if specified
-    if len(meta.Enum) > 0 {
+    // Add enum values if specified (string-only for now)
+    if schema["type"] == "string" && len(meta.Enum) > 0 {
         enumValues := make([]any, len(meta.Enum))
         for i, v := range meta.Enum {
             enumValues[i] = v
         }
         schema["enum"] = enumValues
     }

If you need numeric enums later, we can add a safe parser.

---

271-277: Consider locking down top-level to known atoms.

Optionally set additionalProperties: false to help clients validate unknown keys.

   schema := map[string]any{
       "$schema":     "https://json-schema.org/draft/2020-12/schema",
       "type":        "object",
       "title":       title,
       "description": description,
       "properties":  properties,
+      "additionalProperties": false,
   }

tsunami/prompts/system.md (1)

1270-1318: Resolve markdownlint MD010 (hard tabs).

Replace hard tabs with spaces in changed sections to satisfy MD010.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro